import java.util.Arrays;

public class test {
    //方法
    //什么是方法？
    //方法类似于c语言中函数，
    //方法的形式是：
   /*
    public static 返回值类型 方法名 (参数列表){
             方法体
    }*/


     //其中参数列表可以为空
    // 举例：其中public是访问权限，这个再后面的博客中会阐述到
/*    public static int  add(int a,int b){
        return 3.4;
    }*/

   /* public static void main(String[] args) {
        add(5,2);
        System.out.println();
    }*/

//  main方法：java程序是从main方法开始执行的，这与c语言main函数的作用类似。
    // 一个类中只能有一个main方法.
    // 在main方法格式中：
    //public 是访问权限，static，
    // void是返回值类型， main是main方法特有的函数名
    //String[]  args是字符串类型的数组，作用是？
/*    public static void main(String[] args) {

    }*/
 /*   public static void print(){
        System.out.println("我嵌套调用了方法！");
    }
    public static int add(int x,int y){
      print();
        return x+y;
    }

    public static void main(String[] args) {
        System.out.println(add(5,3));
    }
*/
/*
public static int func1(int x){
    x=10;
    if(x>1){
        return 1;
    }else {
        return 0;
    }
}

    public static void main(String[] args) {
    int x = 5;
        func1(x);
        System.out.println(x);
    }
*/
//方法的重载：
   //在java中可以有两个名字相同的方法,那如何区分不同之处呢？取决于方法的参数列表
    //这样做的目的是方便程序员不需要记录过多的方法名，而选择调用实现的功能大体相同，但操作数据不同的方法。
    //举例：
   /* public static int add(int a,int b){
        return a+b;
    }
    public static double add(double a,double b,double c){
        return a+b+c;
    }*/
    /*  //创建main方法:
    public static void main(String[] args) {

      double d1 = add(3.14,5.2,6.4);
        System.out.println(d1);
        int i = add(5,6);
        System.out.println(i);
    }*/
    //另一种情况：
   /* public static void add(int a,int b) {
        return;
    }
    public static int add(int a,int b){
        return a+b;
    }*/
    //这种情况编译器会报错，这是为什么？因为返回值类型与重载无关
    // 编译器会将方法名与其参数列表看作一个 标识，称为？

    //总结：对于方法重载的规则：
        //   1 方法名必须相同
       //    2  参数列表必须不同
      //     3 返回值类型与重载无关！


// 方法之间的引用问题：
//递归：
    //求阶乘之和
    //求n!+(n-1)!+.....1!
/*public static void main(String[] args) {
    System.out.println(func3(2)) ;  //结果为3
    System.out.println(func3(5));   //结果为：5! + 4!+3!+2!+1! = 120+24+6+2+1 ==153
}*/
/*
  public static int func2(int n){
      int sum = 0;
      if(n==1){
          return 1;
      }else {
        sum = func3(n)+func2(n-1);
      }

      return sum;

  }
*/
//求单个阶乘
 /*   public static int func3(int n){
      int ret =0;
      if(n==1){
          return 1;
      }else {
          ret  = n*func3(n-1);
      }
      return ret;
      }
*/
/*
//汉诺塔问题
    public static void func2(int n,char a,char b,char c){
        //n代表盘子的数量，也表示盘子的序号，越小的盘子，序号越小
        if(n==1){
            System.out.printf(" 转移%d号盘子,从%c柱到%c柱\n",n,a,c);
        }else {
            //如果盘子的数量大于1，则现将A柱上面的一摞盘子转移至B柱
            func2(n-1,a,c,b);
            //然后将此时A柱上最大的盘子转移至C柱
            System.out.printf("转移%d号盘子,从%c柱到%c柱\n",n,a,c);
            //然后将B柱上的一摞盘子转移至C柱，A作为辅柱
            func2(n-1,b,a,c);

        }



    }

    public static void main(String[] args) {
      func2(3,'A','B','C');
    }
*/
/*
public static void main(String[] args) {
    System.out.println(func1(2)) ;  //结果为3
    System.out.println(func1(5));   //结果为：5! + 4!+3!+2!+1! = 120+24+6+2+1 ==153
}
    //求n!+(n-1)!+.....1!
  public   static int func1(int n){
    int ret = 1;
    int sum = 0;
    //首先分析出边界，当n等于1时，则停止自身的嵌套
      if(n==1){
          return 1 ;
      }else {
          //其次找出大问题化解成小问题的规则
          //对于单个项：n! = n*(n-1)!

           ret =  n*func1(n-1);
          //对于多个项相加，每次执行即加上比自身小的项
         sum+=func1(n);
     //我们在增添规则时，在嵌套环境下所依据的规则就发生了变化。

      }


  }
*/
/*   public static void main(String[] args) {
          //数组的定义：
        //定义但不初始化
         int [] arr = new int[5];
         int arr6 [] = {1,5};
         //定义并且初始化
         int []arr1 = new int[]{1,2,3,4};
         int [] arr2 ={1,2,3,4}; //这种方式与上面的没有区别
         //先定义，然后再初始化
         int []arr3;*/
         //arr2 = {1,2,3,4};
         //只有在定义时才可以对数组进行初始化
// 当未初始化时，数组默认的值为0
    /*   for (int i = 0; i < arr.length; i++) {
           System.out.println(arr[i]);
       }*/
     /*  for (int x:arr) {
           System.out.println(x);
       };*/
      /* for (int x:arr) { //但是定义未指定数组大小时，数组中没有默认的值，这是因为并没有给本数组
           //分配空间，无法赋值
           System.out.println(x);
       }*/
   /*    System.out.println(Arrays.toString(arr));
         }*/
         //引用数据类型与基本数据类型的
       // 区别1 :
        //系统在为变量分配内存时，均在栈区上分配，
       // 对于基本数据类型，数据就存放在在栈区分配的内存上
      // 对于引用数据类型，栈区的内存中存放的是类似于地址的数据，我们可以看做地址
     // 在真正存放数据的空间是开辟在堆上的，并将此块空间的地址放在栈区空间内。

 //区别2 ：
    /*   public static void func1(int []array){
           array[0] = 99;
       }

    public static void main(String[] args) {
        int []array = {0,1,2,3,4};
        func1(array);
        System.out.println(Arrays.toString(array));
    }*/
 /*public static void main(String[] args) {
     int []array = {1,2,3};
     int []array1 =array;
     System.out.println(Arrays.toString(array));
     System.out.println(Arrays.toString(array1));

 }
*/
//数组有关方法的使用
/* public static void main(String[] args) {
     int [] arr = {1,2,3,4,5,6,5,};
 int c = Arrays.binarySearch(arr , 6 );
     System.out.println(c);
 }*/
/* public static void main(String[] args) {
     int [] arr = {1,2,3,4,5,6,5,};
    Arrays.sort(arr);
     System.out.println(Arrays.toString(arr));
 }*/


    public static void main(String[] args) {


        //二维数组
        //定义的形式
        int[][] arr = new int[][]{{1, 2, 3}, {1, 2, 3, 4, 5}};
        //当定义指定数组大小时，不能够初始化
        int[][] arr1 = new int[2][3];
        // 不规则定义:只指定行，不指定列，这个规则与c语言中恰好相反
        int[][] arr2 = new int[2][];
        //二维数组的遍历
        //第一种方式：
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                System.out.print(arr[i][j]);
            }
            System.out.println();
        }
        // 第二种方式：
        for (int[] tmp : arr) {
            for (int x : tmp) {
                System.out.print(x);
            }
// 不规则地为二维数组赋值,如何赋值？


            //}
        }
    }
}